home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / mail / mmdf / mmdf-IIb.43 / lib / dial / d_tai.c < prev    next >
Encoding:
C/C++ Source or Header  |  1986-10-02  |  5.4 KB  |  242 lines
  1. #include "util.h"
  2. #include "ll_log.h"
  3. #include  "d_proto.h"
  4. #include "d_structs.h"
  5. #include "cmd.h"
  6.  
  7. /*      tailor the dial package   */
  8. /*
  9.  * Feb 82       Dan Long        Added type field in dports tailor
  10.  * Mar 82    Dan Long    Fixed access setting for d_lines and
  11.  *                added NULL'ing of next item in structs
  12.  *
  13.  */
  14. extern char *def_trn;
  15. extern struct ll_struct ph_log;
  16. #ifdef lint
  17. char *tai_eptr;        /* keep lint happy -- defined in ../mmdf/mm_tai.c */
  18. #else
  19. extern char *tai_eptr;
  20. #endif
  21. extern int errno;
  22. extern struct dialports  *d_prts;
  23. extern int d_numprts;
  24. extern int d_maxprts;
  25. extern struct directlines  *d_lines;
  26. extern int d_numlines;
  27. extern int d_maxlines;
  28. extern char  *d_calllog;
  29. extern unsigned short d_lrill[];
  30. extern unsigned short d_lxill[];
  31. extern struct speedtab d_spdtab[];
  32.  
  33. #define CMDDPORT    1
  34. #define CMDDLINE    2
  35. #define CMDDACCT    3
  36. #define CMDDBADIN   4
  37. #define CMDDBADOUT  5
  38. #define CMDDBAD     6
  39. #define    CMDPHLOG    7
  40. #define    DEFTRAN     8
  41.  
  42. LOCVAR Cmd cmddial[] =
  43. {
  44.     "acct",     CMDDACCT,   1,
  45.     "daccount", CMDDACCT,   1,
  46.     "dacct",    CMDDACCT,   1,
  47.     "dbad",    CMDDBAD,    8,
  48.     "dbadin",    CMDDBADIN,  8,
  49.     "dbadout",    CMDDBADOUT, 8,
  50.     "deftran",  DEFTRAN,    1,
  51.     "dlin",     CMDDLINE,   4,
  52.     "dline",    CMDDLINE,   4,
  53.     "dport",    CMDDPORT,   4,
  54.     "dprt",     CMDDPORT,   4,
  55.     "d_line",   CMDDLINE,   4,
  56.     "d_port",   CMDDPORT,   4,
  57.     "line",     CMDDLINE,   4,
  58.     "phlog",    CMDPHLOG,   1,
  59.     "port",     CMDDPORT,   4,
  60.     0,          0,          0
  61. };
  62.  
  63. #define CMDTABENT ((sizeof(cmddial)/sizeof(Cmd))-1)
  64.  
  65. #define CMDPACCESS  1
  66. #define CMDPPREF    2
  67. #define CMDPPOST    3
  68.  
  69. LOCVAR Cmd cmddparm[] =
  70. {
  71.     "pref",     CMDPPREF,   1,
  72.     "suff",     CMDPPOST,   1,
  73.     "access",   CMDPACCESS, 1,
  74. #ifdef NVRCOMPIL
  75.     "post",     CMDPPOST,   1,
  76. #endif
  77.     0,          0,          0
  78. };
  79.  
  80.  
  81. d_tai (argc, argv)              /* tailor some dial parameter */
  82.     int argc;                   /* number of values     */
  83.     char *argv[];               /* list of values       */
  84. {
  85.     register int ind;
  86.     int tspeed;
  87.  
  88.     switch (cmdbsrch (argv[0], argc - 1, cmddial, CMDTABENT))
  89.     {
  90.     case CMDPHLOG:
  91.         return (tai_log (argc, &argv[1], &ph_log));
  92.  
  93.     case DEFTRAN:
  94.         def_trn = argv[1];
  95.         return(YES);
  96.  
  97.     case CMDDPORT:
  98.         d_prts[d_numprts].p_port = argv[1];
  99.         d_prts[d_numprts].p_lock = argv[2];
  100.         d_prts[d_numprts].p_acu  = argv[3];
  101.         sscanf (argv[4], "%o", &(d_prts[d_numprts].p_speed));
  102.         d_prts[d_numprts].p_ltype = argv[5];
  103.  
  104.         for (ind = 6; ind < argc; ind++)
  105.         if (!lexequ (argv[ind], "="))
  106.         {
  107.             errno = EINVAL;
  108.             tai_eptr = argv[ind];
  109.             argv[ind + 1];
  110.             return (NOTOK);
  111.         }
  112.         else
  113.         {
  114.             ind += 2;
  115.             switch (cmdsrch (argv[ind - 1], argc - ind, cmddparm))
  116.             {
  117.             case CMDPPREF:
  118.                 d_prts[d_numprts].p_acupref = argv[ind];
  119.                 break;
  120.  
  121.             case CMDPPOST:
  122.                 d_prts[d_numprts].p_acupost = argv[ind];
  123.                 break;
  124.  
  125.             case CMDPACCESS:
  126.                 d_prts[d_numprts].p_access = argv[ind];
  127.                 break;
  128.  
  129.             default:
  130.                 errno = EINVAL;
  131.                 tai_eptr = argv[ind - 1];
  132.                 argv[ind + 1];
  133.                 return (NOTOK);
  134.             }
  135.         }
  136.         if (++d_numprts > d_maxprts)
  137.         {
  138.         d_prts[--d_numprts].p_port = NULL;
  139.         errno = ENFILE;
  140.         tai_eptr = argv[0];
  141.         return (NOTOK);
  142.         }
  143.             d_prts[d_numprts].p_port = NULL;
  144.         return (YES);
  145.  
  146.     case CMDDLINE:
  147.         d_lines[d_numlines].l_name = argv[1];
  148.         d_lines[d_numlines].l_tty  = argv[2];
  149.         d_lines[d_numlines].l_lock = argv[3];
  150.  
  151.         sscanf (argv[4], "%d", &tspeed);
  152.         for (ind=0; d_spdtab[ind].s_speed != 0; ind++) {
  153.         if (tspeed == d_spdtab[ind].s_index ||
  154.             strcmp (argv[4], d_spdtab[ind].s_speed) == 0)
  155.             break;
  156.         }
  157.         if (d_spdtab[ind].s_speed == 0) {
  158.             errno = EINVAL;
  159.             tai_eptr = argv[4];
  160.             return(NOTOK);
  161.         }
  162.         d_lines[d_numlines].l_speed = d_spdtab[ind].s_index;
  163.  
  164.  
  165.         for (ind = 5; ind < argc; ind++)
  166.         {
  167.         if (lexequ (argv[ind], "="))
  168.         {
  169.             if ((ind += 2) >= argc)
  170.             {
  171.                 errno = EINVAL;
  172.                 tai_eptr = argv[ind - 1];
  173.                 argv[ind + 1];
  174.             return (NOTOK);
  175.             }
  176.             if (lexequ (argv[ind - 1], "access"))
  177.             d_lines[d_numlines].l_access = argv[ind];
  178.             else
  179.             {
  180.                 errno = EINVAL;
  181.                 tai_eptr = argv[ind - 1];
  182.                 argv[ind + 1];
  183.                 return (NOTOK);
  184.             }
  185.         }
  186.         else
  187.         {
  188.                 errno = EINVAL;
  189.                 tai_eptr = argv[ind];
  190.                 argv[ind + 1];
  191.             return (NOTOK);
  192.         }
  193.         }
  194.         if (++d_numlines > d_maxlines)
  195.         {
  196.         d_lines[--d_numlines].l_tty = NULL;
  197.         errno = ENFILE;
  198.         tai_eptr = argv[0];
  199.         return (NOTOK);
  200.         }
  201.         d_lines[d_numlines].l_tty = NULL;
  202.         return (YES);
  203.  
  204.     case CMDDACCT:
  205.         d_calllog = argv[1];
  206.         return (YES);
  207.  
  208.     case CMDDBADOUT:          /* can't send bare */
  209.         return (d_vec (argc, &argv[1], d_lxill));
  210.  
  211.     case CMDDBADIN:           /* can't receive bare */
  212.         return (d_vec (argc, &argv[1], d_lrill));
  213.  
  214.     case CMDDBAD:             /* send/receive list the same */
  215.         if (d_vec (argc, &argv[1], d_lxill) == YES &&
  216.             d_vec (argc, &argv[1], d_lrill) == YES)
  217.             return (YES);
  218.  
  219.     }
  220.     return (NO);                /* not a dial parameter         */
  221. }
  222. /* */
  223.  
  224. d_vec (argc, argv, vec)
  225.     int argc;
  226.     char *argv[];
  227.     unsigned short vec[];
  228. {
  229.     register int ind;
  230.     int tmp;
  231.  
  232.     if (argc > 8)
  233.     argc = 8;               /* only 128 bits @ 16 bits/word */
  234.     for (ind = 0; ind < argc; ind++) {
  235.     sscanf (argv[ind], "%o", &tmp);
  236.     /* convert to short */
  237.     vec[ind] = (unsigned) tmp;
  238.     }
  239.  
  240.     return (YES);
  241. }
  242.